package com.util;

import java.util.Date;

import org.apache.commons.lang.StringUtils;
import org.apache.commons.lang.math.NumberUtils;



public class ArrayUtils extends org.apache.commons.lang.ArrayUtils {
	
	/**
	 * 返回true 如果指定的value在当前字符串数组array中，否则返回false
	 * @param array
	 * @param value
	 * @return
	 */
	public static boolean contains(String array,String value){
		return contains(array, ",", value);
	}
	/**
	 * 返回true 如果指定的value在当前字符串以split分割的数组array中，否则返回false
	 * @param array
	 * @param split
	 * @param value
	 * @return
	 */
	public static boolean contains(String array,String split,String value){
		boolean flag=false;
		if(null==value || "".equals(value.trim())) return false;
		String []arr=array.split(split);
		for(String str :arr){
			if(value.equals(str)) {
				flag=true;break;
			}
		}
		return flag;
	}
	/**
	 * 返回true 如果指定的value在当前数组array中，否则返回false
	 * @param array
	 * @param value
	 * @return
	 */
	public static boolean contains(String []array,String value){
		boolean flag=false;
		if(null==value) return false;
		for(String str :array){
			if(value.equals(str)) {
				flag=true;break;
			}
		}
		return flag;
	}
	
	/**
	 * 返回true如果指定的value是在当前这个字符串以默认的分割符“，”分割的数组的区间内某一个元素开头，否则返回false
	 * @param array 
	 * @param value
	 * @return
	 */
	public static boolean containsBetweens(String array,String value){		
		return containsBetweens(array,",",value);
	}
	/**
	 * 返回true如果指定的value是在当前这个字符串以指定的分割符split分割的数组的区间内的某一个元素开头，否则返回false
	 * @param array 
	 * @param value
	 * @param split
	 * @return
	 */
	public static boolean containsBetweens(String array,String split,String value){		
		if(StringUtils.isBlank(value) ) return false;
		String arr[]=array.indexOf(split)==-1?new String []{array,array}:array.split(split);
		if(arr.length>2) return false;
		if(value.compareTo(arr[0])>=0 && (value.compareTo(arr[1])<=0 || value.startsWith(arr[1]))) return true;		
		return false;
	}
	/**
	 * 返回true如果指定的value是在当前这个字符数组的区间内的某一个元素开头，否则返回false
	 * @param array 
	 * @param value
	 * @return
	 */
	public static boolean containsBetweens(String [] array,String value){		
		if(StringUtils.isBlank(value) ) return false;		
		if(array.length>2) return false;
		if(value.compareTo(array[0])>=0 && (value.compareTo(array[1])<=0 || value.startsWith(array[1]))) return true;		
		return false;
	}
	public static boolean containsBetweensArraysWithSplit(String [] array,String split,String value){		
		if(StringUtils.isBlank(value) ) return false;		
		for(int i=0;i<array.length;i++){
			if(containsBetweens(array[i], split, value)){
				return true;
			}
		}
		return false;
	}
	public static boolean containsBetweensArraysWithSplit(String array,String split,String value){		
		if(StringUtils.isBlank(value) ) return false;
		String [] arrays=array.split(",");		
		return containsBetweensArraysWithSplit(arrays, split, value);
	}
	/**
	 * 返回true如果指定长度的value是在当前这个字符串以指定侵害符split分割后的数组的区间内的某一个元素开头并排除except元素，否则返回false
	 * @param array 
	 * @param value
	 * @param split
	 * @param length
	 * @param except
	 * @return
	 */
	public static boolean containsBetweensExcept(String array,String split,String value,int length,String except){
		boolean rs = false;
		if(StringUtils.isBlank(value) || value.length()<length) return rs;
		String val=value.substring(0, length).toUpperCase();
		String arr[]=array.indexOf(split)==-1?new String []{array,array}:array.split(split);
		if(val.compareTo(arr[0])>=0 && (val.compareTo(arr[1])<=0 || val.startsWith(arr[1]) ) && !containsStartsWith(except, value)) return true;		
		return rs;
	}
	/**
	 * 返回true如果指定的value是以当前这个数组array中某一个元素开头，否则返回false
	 * @param array 
	 * @param value
	 * @return
	 */
	public static boolean containsStarts(String[] array,String value){
		boolean rs = false;
		if(StringUtils.isBlank(value)) return rs;		
		for (String str : array) {
			if(value.startsWith(str)){
				rs = true;
				break;
			}
		}
		return rs;
	}
	/**
	 * 返回true如果指定的value是以当前这个字符串数组array（分割符为','）中某一个元素开头，否则返回false
	 * @param array 
	 * @param value	
	 * @return
	 */
	public static boolean containsStartsWith(String array,String value){
		boolean rs = false;
		if(StringUtils.isBlank(value) ) return rs;		
		String arr[]=array.indexOf(",")==-1?new String []{array}:array.split(",");
		for (String str : arr) {
			if(value.startsWith(str)){
				rs = true;
				break;
			}
		}
		return rs;
	}
	/**
	 * 返回true如果指定长度的value是以当前这个字符串数组array（分割符为','）中某一个元素开头，否则返回false
	 * @param array 
	 * @param value
	 * @param length
	 * @return
	 */
	public static boolean containsStartsWith(String array,String value,int length){
		boolean rs = false;
		if(StringUtils.isBlank(value) || value.length()<length) return rs;
		value=value.substring(0, length).toUpperCase();
		String arr[]=array.indexOf(",")==-1?new String []{array}:array.split(",");
		for (String str : arr) {
			if(value.startsWith(str)){
				rs = true;
				break;
			}
		}
		return rs;
	}
	/**
	 * 返回true如果指定的value是以当前这个数组array中某一个元素开头，否则返回false（没有处理value为null的情况）
	 * @param array 
	 * @param value
	 * @return
	 */
	public static boolean containsStartsWith(String[] array,String value){
		boolean rs = false;
		for (String str : array) {
			if(value.startsWith(str)){
				rs = true;
				break;
			}
		}
		return rs;
	}
	/**
	 * 返回true如果指定长度的value是以当前这个数组array中某一个元素开头，否则返回false
	 * @param array 
	 * @param value
	 * @param length
	 * @return
	 */
	public static boolean containsStartsWith(String[] array,String value,int length){
		boolean rs = false;
		if(StringUtils.isBlank(value) || value.length()<length) return rs;
		value=value.substring(0, length).toUpperCase();
		for (String str : array) {
			if(value.startsWith(str)){
				rs = true;
				break;
			}
		}
		return rs;
	}
	/**
	 * 返回true如果指定长度的value是在当前这个字符串以“，”分割后的数组的区间内的某一个元素开头并排除except元素，否则返回false
	 * @param array 
	 * @param value
	 * @param length
	 * @param except
	 * @return
	 */
	public static boolean containsStartsWithExcept(String array,String value,int length,String except){		
		return containsStartsWithExcept(array, ",", value, length, except);
	}
	/**
	 * 返回true如果指定长度的value是在当前这个字符串以指定侵害符split分割后的数组的区间内的某一个元素开头并排除except元素，否则返回false
	 * @param array 
	 * @param value
	 * @param split
	 * @param length
	 * @param except
	 * @return
	 */
	public static boolean containsStartsWithExcept(String array,String split,String value,int length,String except){
		boolean rs = false;
		if(StringUtils.isBlank(value) || value.length()<length) return rs;
		value=value.substring(0, length).toUpperCase();
		String arr[]=array.indexOf(split)==-1?new String []{array}:array.split(split);
		for (String str : arr) {
			if(value.startsWith(str) && !containsStartsWith(except,value)){
				rs = true;
				break;
			}
		}
		return rs;
	}	
	/**
	 * 返回true如果指定的这个数组array中某一个元素是以当前value开头，否则返回false（处理了value和数组中的元素都为null的情况）
	 * @param array 
	 * @param value
	 * @return
	 */
	public static boolean startsWith(String[] array,String value){
		boolean rs = false;
		for (String str : array) {
			if((str==null && value==null) || str.startsWith(value)){
				rs = true;
				break;
			}
		}
		return rs;
	}
	
	/**
	 * 返回日期数组中最大的或最小的日期
	 * @param dateArr
	 * @param max
	 * @return the max or the min Date
	 */
	public static Date maxOrMinDate(Date []dateArr,boolean max){
		if(null==dateArr) return null;
		Date date = dateArr[0];
		for (int i = 1; i < dateArr.length; i++) {
			if(dateArr[i]==null)
				continue;
			if (date == null ) 
				date=dateArr[i];				
			if (i < dateArr.length - 1 && dateArr[i + 1] != null) {
				if (max && date.before(dateArr[i + 1])) {
					date = dateArr[i + 1];
				} else if (!max && date.after(dateArr[i + 1])) {
					date = dateArr[i + 1];
				}
			}
		}
		return date;
	}
	public static int getMaxOrMin(int[] array,boolean max){
		int m=array[0];
		for(int i=0;i<array.length;i++){
			if(max){
				if(array[i]>m)
					m=array[i];
			}else{
				if(array[i]<m)
					m=array[i];
			}
		}
		return m;
	}
	public static double getMaxOrMin(double[] array,boolean max){
		double m=array[0];
		for(int i=0;i<array.length;i++){
			if(max){
				if(array[i]>m)
					m=array[i];
			}else{
				if(array[i]<m)
					m=array[i];
			}
		}
		return m;
	}
	public static int getMaxOrMinIndex(double[] array,boolean max,double d){
		int m=0;
		for(int i=0;i<array.length;i++){
			if(max){
				if(array[i]>=d)
					m=i;
			}else{
				if(array[i]<m)
					m=i;
			}
		}
		return m;
	}
	public static int[] StringToIntArray(String array){
    	int t[]=null;
    	if(array.startsWith("[") && array.endsWith("]")){
			array=array.replace("[", "").replace("]", "");
		}else if(!array.startsWith("[") && !array.endsWith("]")){
			String [] arr=array.split(",");
			int length=arr.length;
			t=new int[length];
			for(int i=0;i<length;i++){
				t[i]=NumberUtils.toInt(arr[i].trim());
			}
		}else {
			throw new RuntimeException(array+" can not parse to int array ");
		}		
		return t;
	}
	public static String toString(Object arr[]){
		if(arr==null)return "";
		StringBuilder sb=new StringBuilder();
		for(Object o:arr){
			sb.append(o==null?"":o.toString()).append(",");
		}
		if(sb.length()>0)
			sb.deleteCharAt(sb.length()-1);
		return sb.toString();
	}
	public static String toString(int arr[]){
		if(arr==null)return "";
		StringBuilder sb=new StringBuilder();
		for(int o:arr){
			sb.append(o).append(",");
		}
		if(sb.length()>0)
			sb.deleteCharAt(sb.length()-1);
		return sb.toString();
	}
	public static void main(String[] args) {
	} 
}
